Week 2: Java Specifics

Scope rules

all variables need to be declared

Local variables visible from their point of declaration until end of block

Class fields and methods visible everywhere in class

Exceptions

IOException myFault = new IOException();

throw myFault;

throw new IOException("write error");

Try-Catch

Exceptions can be "caught" by a try statement. General form:

        try {
            ...
        } catch (Exception1 ex) {
            ...
        } catch (Exception2 ex) {
            ...
        }

Catch clauses are tried in sequence. First clause that matches the thrown exception is executed.

Try-Finally

An optional finally section in the try statement contains code that will be executed whether an exception was raised or not.

Example

try {
    out.write(...);
} finally {
    out.close();
}

This is equivalent to:

try {
    out.write(...);
    out.close();
} catch (Throwable ex) {
    out.close();
    throw ex;
}

Throws Clauses

Uncaught exceptions have to be declared in a method signature:

void write2(OutputStream out, int x) 
           throws IOEception {
     out.write(x); out.write(x);
}

Only exceptions: Exceptions inheriting from RuntimeException or Error

Throwable -+--- Exception -+---- ...
           |               |
           |               +--RuntimeException
           +--- Error

Packages

• Classes are organized into packages.
• The fully qualified name of a class consists of the package name and the class name, separated by ".".
• Package names are sequences of identifiers, separated by "."
• Typical organization:

group . project . class
company . library . class

• E.g.

        pizza.compiler.Main
      java.lang.System

• Most implementations let packages correspond to file directories.
• A package clause such as

package myGroup.myPackage;

• at the beginning of a .java file declares all classes in the file to be members of that package.

Name Spaces

• Outermost scope: package.
• Every class is a member of some package.
• If no package is declared the empty package is assumed to contain the class.
• In Java 1.1, classes can be nested.
• Every method and field is a member of a class.
• Methods can also contain parameters and local variables, but not other methods
• Fully qualified name of a class:

packagename . classname

• Inside a package, it is enough to just use classname.

Package <=> Directory

The package of a class influences where the class is searched.

Interpreter and compiler will look for a class such as pizza.compiler.Main in the directory pizza/compiler/Main.

The root of the search is a directory on the CLASSPATH.

Setting the compiler's -d option will alsways ensure that classes end up in the right directory.

Imports

• It is quite tedious to have to use fully qualified file names all the time.
• To use the short name, use an import clause:

• Always implicitly imported: java.lang .*

The Standard Library

Organized as packages:

Class Extension

• Idiom:

class X extends Superclass [implements Interface ...]

• No multiple inheritance.
• Every class (except java.lang.Object) has exactly one superclass.
• If no extends clause is given, Object is assumed.
• Extension has two effects:
• It creates a subtype
• It includes all declarations of the extended class in the extending class, unless they are overridden.

Subtyping

• If class X extends class Y, X is said to be a subclass of Y.
• In this case, an instance of class X can be used whereever an instance of class Y is expected.

class X extends Y { ... 

X anX;
Y aY;

aY = anX;      // OK;

anX = (X)aY;  // explicit type conversion required.

• Because of subclassing, the static, declared type of a variable might differ from the dynamic type of the run-time value it contains.
• More precisely: The dynamic type can be a subtype of the static type.

---

Typecasts and typetests

• A type conversion (C)expr checks whether the dynamic type of expr is (a subtype of) class C. If not, a ClassCastException is thrown.
• A type test expr instanceof C tests whether the dynamic type of expr is (a subtype of) class C. The resultif this operation is a boolean.
• Example:

class String { 
    ...
    boolean equals(Object other) {
        if (other instanceof String) {
            String that = (String)other;
            if (this.len != that.len) return false;
            for (int i = 0; i < this.len; i++) {
                if (this.chars[i] != that.chars[i])
                    return false;

            return true;
        }
    }

Subtyping and Arrays

String[] a = {"hello", "world!"};

Object[] b = a;            // OK because of array subtyping rule

b[0] = new Integer(1);     // will throw an ArrayStoreException ...

String s = a[0];           // ... to avoid having to assign an Integer
                           // to a String

Inheritance

class Base {

   print(Object x) {
     System.out.println(x);
   }

   printArray(Object[] xs) {
     for (int i = 0; i < xs.length; i++) print(xs[i]);
   }
}

class Sub extends Base {

   PrintStream log = ...;

   print(Object x) / overrides Base.print {
     log.println(x);
   }

}

Base x = new Sub(); 

x.print("hello") // will print to log

The Object Class

String toString();

boolean equals(Object other);

int hashCode();

Overloading

void print(String x) { ... }

void print(Exception x) { ... }

void print(int x) { ... }

void print(int x, int precision) { ... }

Access Modifiers

Other Field- and Method-Declaration Modifiers

• static
• nce per class, rather than once per object
• final
• for methods: cannot be overridden.
• for fields: cannot be re-assigned.
• abstract
• only for methods: implementation deferred to subclasses. Example:

abstract method print(); 

• synchronized
• only for methods: only one concurrent access allowed.
• native
• only for methods: implemented by non-Java code
• transient
• only for fields: need not be written to permanent storage
• volatile
• only for fields: might be changed from outside program.

Class Modifiers

Interfaces

• Interfaces specify supported operations without implementing them.
• Componets of interfaces:
• methods
• constants
• but no method implementations, variables.

interface Storable {
    int READ = 0;
    int WRITE = 1;
    
    byte[] get();
    put(byte[] data);

    int lastOp(); // returns READ or WRITE;
}



Interfaces

interface Colors {
    int Red = 0;
    int Green = Red + 1;
    int Blue = Green + 1;
}

class C implements /* imports, really */ Colors

Example: Sets

public interface Set {
    Set insert(Object elem);
    Set delete(Object elem);
    boolean member(Object elem);
}

An Implementation of Sets:

abstract public class List implements Set {

    abstract Set insert(Object elem);
    abstract Set delete(Object elem);
    abstract boolean member(Object elem);

}

Empty Lists

    public class Empty extends List {

        NonEmpty(Object head; List rest) {
            this.head = head;
            this.rest = rest;
        }

    Set insert(Object elem) {
        return new NonEmpty(elem, this);
    }

    Set delete(Object elem) {
        return this;
    }

    boolean member(Object elem) {
        return false;
    }

    }

Assignment

An interface for Tables is given as follows:

interface Table {
    void put(Object key, Object data);
    Object get(Object key);
}